/*
 * Copyright (c) 2025 Industrial Software Feature Database
 */
package com.comac.ins.isfd.util.bdfparser.output;

import com.comac.ins.isfd.util.bdfparser.entities.bdf.cards.BaseCard;
import com.comac.ins.isfd.util.bdfparser.entities.bdf.sections.BulkDataEntry;
import com.comac.ins.isfd.util.bdfparser.enums.SearchTypeEnum;
import com.comac.ins.isfd.util.bdfparser.enums.cardeums.CardTypeEnums;
import com.comac.ins.isfd.util.bdfparser.parsers.BasicCardUtils;
import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 获取BDF实体类中的一些信息
 */
@Slf4j
public class BDFGetters {

    /**
     * 根据搜索类型返回数据
     *
     */
    public static List<BaseCard> searchCardsByCondition(BulkDataEntry bulkDataEntry, SearchTypeEnum seearchType, String value) {
        try {
            switch (seearchType) {
                case CARD_ID -> {
                    return getCardsById(bulkDataEntry, Integer.parseInt(value));
                }
                case CARD_NAME -> {
                    return getCardsByName(bulkDataEntry, value);
                }
                case CARD_FIELD -> {
                    return getCardsByField(bulkDataEntry, value);
                }
                case RAW_DATA_ROW -> {
                    return getCardsByRowNumber(bulkDataEntry, Integer.parseInt(value));
                }
                default -> {
                    return null;
                }
            }
        } catch (Exception e) {
            log.error("BDF内容检索失败，error: " + e);
            return null;
        }
    }

    /**
     * 根据卡片类型获取卡片列表
     */
    public static List<BaseCard> getCardsByName(BulkDataEntry bulkDataEntry, String cardName) {
        // 验证是支持的卡片类型
        if (!bulkDataEntry.getCardCount().keySet().contains(cardName)) {
            log.error("没有该卡片类型！card: " + cardName);
        }
        // 获取卡片
        List<BaseCard> allCards = bulkDataEntry.getCardList();
        return allCards.stream().filter(
            card -> card.getName().equals(cardName)).toList();
    }

    /**
     * 根据卡片id获取卡片列表
     */
    public static List<BaseCard> getCardsById(BulkDataEntry bulkDataEntry, Integer cardId) {
        // 获取卡片
        List<BaseCard> allCards = bulkDataEntry.getCardList();
        return allCards.stream().filter(
            card -> card.getId().equals(cardId)).toList();
    }

    /**
     * 根据卡片field获取卡片列表
     */
    public static List<BaseCard> getCardsByField(BulkDataEntry bulkDataEntry, String fieldContent) {
        // 获取卡片
        List<BaseCard> allCards = bulkDataEntry.getCardList();
        return allCards.stream()
            .filter(card -> card.getFields().stream()
                .flatMap(List::stream)
                .anyMatch(field -> field.equals(fieldContent)))
            .toList();
    }

    /**
     * 根据原数据行 获取卡片列表
     */
    public static List<BaseCard> getCardsByRowNumber(BulkDataEntry bulkDataEntry, Integer rowNumber) {
        // 获取卡片
        List<BaseCard> allCards = bulkDataEntry.getCardList();
        return allCards.stream()
            .filter(card -> card.getRawDataLines().stream()
                .anyMatch(rawDataLine -> rawDataLine.getRowNumber() == rowNumber))
            .toList();
    }

    /**
     * 根据卡片类型+id获取卡片
     */
    public static BaseCard getCardsByNameId(List<BaseCard> cardList, String cardName, Integer id) {
        // 获取卡片
        Map<String, BaseCard> cardMap = getCardUniqueIdMap(cardList);
        // 验证是支持的卡片类型
        if (!cardMap.keySet().contains(cardName)) {
            log.error("没有该卡片类型！card: " + cardName);
        }
        return cardMap.get(cardName.strip()+" "+id.toString().strip());
    }

    /**
     * 根据卡片名称对卡片进行分类展示
     *
     */
    public static Map<String, List<BaseCard>> organizeCardListByName(Map<String, Integer> cardCount, List<BaseCard> cardList) {
        Map<String, Integer> checkCount = new HashMap<>(cardCount);
        Map<String, List<BaseCard>> organizedCardList = new HashMap<>();
        if (cardList == null || cardList.isEmpty()) {
            return organizedCardList; // 如果卡片列表为空，直接返回空的分类结果
        }
        for (BaseCard card : cardList) {
            if (card == null || card.getName() == null) {
                log.warn("有无效卡片！card: " + card.getName());
                continue; // 跳过无效的卡片或名称为空的卡片
            }
            // 添加到分类结果中
            organizedCardList.computeIfAbsent(card.getName(), k -> new ArrayList<>()).add(card);
            // 更新卡片计数
            checkCount.merge(card.getName(), -1, Integer::sum);// 更新卡片计数
            checkCount.remove(card.getName(), 0);
        }
        // 检查是否存在未匹配的卡片计数
        if (!checkCount.isEmpty()) {
            log.warn("以下卡片计数存在异常（可能未匹配所有卡片）： " + cardCount);
        }
        return organizedCardList;
    }

    /**
     * 获取卡片标识列表
     *
     */
    public static Map<String, BaseCard> getCardUniqueIdMap(List<BaseCard> cardList) {
        Map<String, BaseCard> cardUniqueIdMap = new HashMap<>();
        for (BaseCard card : cardList) {
            String cardKey = card.getUniqueId();
            if (cardUniqueIdMap.containsKey(cardKey)) {
                log.error("重复卡片! 跳过当前卡片，card:" + cardKey);
                continue;
            }
            cardUniqueIdMap.put(cardKey, card);
        }
        return cardUniqueIdMap;
    }

    /**
     * 获取解析行列表
     */





    public static void main(String[] args) {}


}
